package com.demo.java.OD651_700.OD657;

import java.util.Scanner;
import java.util.HashMap;
import java.util.Map;

/**
 * @author bug菌
 * @Source 公众号：猿圈奇妙屋
 * @des： 【带传送阵的矩阵游离(A卷-100分)】问题
 * @url： https://blog.csdn.net/weixin_43970743/article/details/147040653
 */
public class OdMain {
    public static void main(String[] args) {
        // 处理输入
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();  // 读取行数n
        int m = in.nextInt();  // 读取列数m

        int[][] matrix = new int[n][m];  // 初始化矩阵
        // 读取矩阵元素
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                matrix[i][j] = in.nextInt();  // 读取每个元素的值
            }
        }

        // 从左上角到右下角计算最小路径
        Map<Integer, Integer> left_map = new HashMap<>();  // 存储每个位置的最小路径
        int[][] left_arr = new int[n][m];  // 左边路径存储数组
        int distance = 0;

        // 遍历矩阵，计算从左上角到右下角的最短路径
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < m; k++) {
                if (i == 0) {  // 第一行
                    if (k == 0) {
                        distance = 0;
                        left_arr[i][k] = 0;
                    } else {
                        distance = Math.abs(matrix[i][k] - matrix[i][k - 1]) + left_arr[i][k - 1];
                        left_arr[i][k] = distance;
                    }
                }

                if (i != 0) {  // 其他行
                    if (k == 0) {  // 第一列
                        distance = Math.abs(matrix[i][k] - matrix[i - 1][k]) + left_arr[i - 1][k];
                        left_arr[i][k] = distance;
                    } else {  // 其他位置
                        int top = matrix[i - 1][k];
                        int left = matrix[i][k - 1];
                        distance = Math.min(Math.abs(matrix[i][k] - top) + left_arr[i - 1][k], Math.abs(matrix[i][k] - left) + left_arr[i][k - 1]);
                        left_arr[i][k] = distance;
                    }
                }

                // 存储每个位置的最小路径
                if (left_map.containsKey(matrix[i][k])) {
                    left_map.put(matrix[i][k], Math.min(left_map.get(matrix[i][k]), distance));
                } else {
                    left_map.put(matrix[i][k], distance);
                }
            }
        }

        // 从右下角到左上角计算最小路径
        Map<Integer, Integer> right_map = new HashMap<>();
        int[][] right_arr = new int[n][m];
        for (int i = n - 1; i >= 0; i--) {
            for (int k = m - 1; k >= 0; k--) {
                if (i == n - 1) {  // 最后一行
                    if (k == m - 1) {
                        distance = 0;
                        right_arr[i][k] = 0;
                    } else {
                        distance = Math.abs(matrix[i][k] - matrix[i][k + 1]) + right_arr[i][k + 1];
                        right_arr[i][k] = distance;
                    }
                }

                if (i != n - 1) {  // 其他行
                    if (k == m - 1) {  // 最后一列
                        distance = Math.abs(matrix[i][k] - matrix[i + 1][k]) + right_arr[i + 1][k];
                        right_arr[i][k] = distance;
                    } else {  // 其他位置
                        int bottom = matrix[i + 1][k];
                        int right = matrix[i][k + 1];
                        distance = Math.min(Math.abs(matrix[i][k] - bottom) + right_arr[i + 1][k], Math.abs(matrix[i][k] - right) + right_arr[i][k + 1]);
                        right_arr[i][k] = distance;
                    }
                }

                // 存储每个位置的最小路径
                if (right_map.containsKey(matrix[i][k])) {
                    right_map.put(matrix[i][k], Math.min(right_map.get(matrix[i][k]), distance));
                } else {
                    right_map.put(matrix[i][k], distance);
                }
            }
        }

        // 最终结果：合并左侧和右侧的结果，取最小值
        int res = Integer.MAX_VALUE;
        for (Map.Entry<Integer, Integer> entry : left_map.entrySet()) {
            res = Math.min(res, left_map.get(entry.getKey()) + right_map.get(entry.getKey()));
        }

        // 输出结果
        System.out.println(res);
    }
}